home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / video / fly8111-.000 / fly8111- / fly8 / nav.c < prev    next >
C/C++ Source or Header  |  1979-12-31  |  6KB  |  327 lines
  1. /* --------------------------------- nav.c ---------------------------------- */
  2.  
  3. /* This is part of the flight simulator 'fly8'.
  4.  * Author: Eyal Lebedinsky (eyal@ise.canberra.edu.au).
  5. */
  6.  
  7. /* handle nav data.
  8. */
  9.  
  10. #include "plane.h"
  11.  
  12.  
  13. static int        maxnav = 0;
  14. struct ils        FAR *ils = 0;
  15. static struct ils    Tnav = {0};
  16.  
  17. #define READFLD        Tnav
  18.  
  19. static struct FldTab FAR NavTbl[] = {
  20.     READS (name),
  21.     READI (R[X]),
  22.     READI (R[Y]),
  23.     READI (R[Z]),
  24.     READI (longitude),
  25.     READI (latitude),
  26.     READI (l[X]),
  27.     READI (l[Y]),
  28.     READI (g[X]),
  29.     READI (g[Y]),
  30.     READI (localizer),
  31.     READI (glidepath),
  32. {0, 0}};
  33.  
  34. #undef READFLD
  35.  
  36. LOCAL_FUNC void NEAR
  37. ils_free ()
  38. {
  39.     int    n;
  40.  
  41.     if (ils) {
  42.         for (n = 0; n < maxnav; ++n)
  43.             ils[n].name = STRfree (ils[n].name);
  44.         ils = memory_cfree (ils, sizeof (*ils), maxnav + 1);
  45.     }
  46. }
  47.  
  48. extern int FAR
  49. nav_init (void)
  50. {
  51.     int    i, l, n;
  52.     long    t;
  53.     FILE    *ifile;
  54.     char    line[256];
  55.  
  56.     if (!st.navname)
  57.         st.navname = STRdup ("fly");
  58.  
  59.     Sys->BuildFileName (st.filename, st.fdir, st.navname, NAV_EXT);
  60.     if (!(ifile = fopen (st.filename, RTMODE))) {
  61.         LogPrintf ("missing nav file: %s\n", st.filename);
  62.         return (-1);
  63.     }
  64.     LogPrintf ("nav      %s\n", st.filename);
  65.  
  66.     st.lineno = 0;
  67.  
  68.     if (field_find (ifile, line))
  69.         goto badret;
  70.     if (1 != sscanf (line, "%ld", &t) || t < 1) {
  71.         LogPrintf ("%s %ld: bad nav csize\n",
  72.             st.filename, st.lineno);
  73.         goto badret;
  74.     }
  75.     maxnav = (int)t;
  76.     LogPrintf ("      %d points\n", maxnav);
  77.  
  78.     if (!(ils = (struct ils *)memory_calloc (sizeof (*ils), maxnav + 1))) {
  79.         LogPrintf ("%s %ld: no nav mem\n",
  80.             st.filename, st.lineno);
  81.         goto badret;
  82.     }
  83.  
  84.     for (n = 0; n < maxnav; ++n) {
  85.         for (i = 0; (l = NavTbl[i].type) > 0; ++i) {
  86.         if (field_read (ifile, &NavTbl[i], line) < 0)
  87.             goto badret;
  88.         }
  89.         memcpy (&ils[n], &Tnav, sizeof (Tnav));
  90.     }
  91.     ils[n].name = 0;
  92.  
  93.     fclose (ifile);
  94.     return (0);
  95.  
  96. badret:
  97.     fclose (ifile);
  98.     ils_free ();
  99.     return (-1);
  100. }
  101.  
  102. extern void FAR
  103. nav_term (void)
  104. {
  105.     ils_free ();
  106. }
  107.  
  108.  
  109. extern int FAR
  110. ils_get (OBJECT *p)
  111. {
  112.     int        t;
  113.     long        tx, ty, tz;
  114.     ANGLE        a;
  115.     struct ils    *b;
  116.  
  117.     t = EX->ils - 1;
  118.     if (t < 0)
  119.         t = p->home;
  120.     b = &ils[t];
  121.  
  122. /* glide path deviation.
  123. */
  124.     tx = (p->R[X] - b->R[X])/VONE;
  125.     ty = (p->R[Y] - b->R[Y])/VONE;
  126.     tz = (p->R[Z] - b->R[Z])/VONE;
  127.     if (labs(tx) > 25000L || labs(ty) > 25000L || labs(tz) > 25000L) {
  128.         EX->misc[14] = 0;
  129.         EX->misc[15] = 0;
  130.         return (1);            /* too far out */
  131.     }
  132.  
  133.     t = ihypot2d ((int)tx-b->g[X], (int)ty-b->g[Y]); /* dist. to beacon */
  134.     a = b->glidepath - ATAN ((int)tz, t);
  135.     t = a - EX->misc[14];
  136.     if (iabs(t) > 4)
  137.         a = EX->misc[14] + t/4;
  138.     EX->misc[14] = a;
  139.  
  140. /* localizer deviation.
  141. */
  142.     a = ATAN ((int)tx-b->l[X], (int)ty-b->l[Y]) - b->localizer;
  143.     EX->misc[15] = a;
  144.  
  145.     return (0);
  146. }
  147.  
  148. #define XFULL    DEG(2.5)
  149. #define YFULL    DEG(0.75)
  150.  
  151. extern void FAR
  152. show_ils (HUD *h, OBJECT *p, int sx, int sy, int orgx, int orgy, int ss,
  153.     int shifty)
  154. {
  155.     int        x, y, xref, yref, t, i, dd;
  156.     ANGLE        a;
  157.     struct ils    *b;
  158.  
  159.     if (!(EX->hud2 & HUD_ILS))
  160.         return;
  161.  
  162.     orgy += shifty;
  163.  
  164.     b = &ils[EX->ils-1];
  165.  
  166.     gr_color (ST_HFG);
  167.  
  168. /* show navigation data
  169. */
  170.     dd = num_size (9L, ss);
  171.     x = orgx + sx - dd*9;
  172.     y = orgy + sy - 2;
  173.  
  174.     t = ANG2DEG(EX->ilsHeading);
  175.     if (t < 0)
  176.         t += 360;
  177.     stroke_frac (x, y, t , 3, 0, ss, ST_HFG);
  178.     stroke_frac (x+dd*4, y, EX->ilsRange, 0, 1, ss, ST_HFG);
  179.  
  180.     y -= ss;
  181.     stroke_str (x, y, b->name, ss, ST_HFG);
  182.  
  183.     xref = fmul (sx, FONE/8*7);
  184.     yref = fmul (sy, FONE/8*7);
  185.  
  186. /* localizer deviation.
  187. */
  188.     a = EX->misc[15];
  189.     if (a > XFULL)
  190.         x = xref;
  191.     else if (a < -XFULL)
  192.         x = -xref;
  193.     else
  194.         x = muldiv (xref, a, XFULL);
  195.     x = orgx + x;
  196.     gr_move (x, orgy-yref);
  197.     gr_draw (x, orgy+yref);
  198.     t = sx / 64;
  199.     for (i = 1; i < 5; ++i) {
  200.         y = muldiv (yref, i, 5);
  201.         gr_move (x-t, orgy+y);
  202.         gr_draw (x+t, orgy+y);
  203.         gr_move (x-t, orgy-y);
  204.         gr_draw (x+t, orgy-y);
  205.     }
  206.     gr_move (x-3*t, orgy);
  207.     gr_draw (x+3*t, orgy);
  208.  
  209. /* glide slope deviation.
  210. */
  211.     a = EX->misc[14];
  212.     if (a > YFULL)
  213.         y = yref;
  214.     else if (a < -YFULL)
  215.         y = -yref;
  216.     else
  217.         y = muldiv (yref, a, YFULL);
  218.     y = orgy - y;
  219.     gr_move (orgx-xref, y);
  220.     gr_draw (orgx+xref, y);
  221.     t = sy / 64;
  222.     for (i = 1; i < 5; ++i) {
  223.         x = muldiv (xref, i, 5);
  224.         gr_move (orgx+x, y-t);
  225.         gr_draw (orgx+x, y+t);
  226.         gr_move (orgx-x, y-t);
  227.         gr_draw (orgx-x, y+t);
  228.     }
  229.     gr_move (orgx, y-3*t);
  230.     gr_draw (orgx, y+3*t);
  231. }
  232.  
  233. #undef XFULL
  234. #undef YFULL
  235.     
  236. extern int FAR
  237. menu_ils (void)
  238. {
  239.     MENU    *MenuILS;
  240.     OBJECT    *p;
  241.     int    sel, i, n, nEntries, EntrySize;
  242.  
  243.     if (IS_PLANE(CV))
  244.         p = CV;
  245.     else {
  246.         p = 0;
  247.         MsgWPrintf (100, "not a aplane");
  248.     }
  249.  
  250.     for (nEntries = 0; ils[nEntries].name; ++nEntries)
  251.         ;
  252.     nEntries += 2;        /* "off" and "home" */
  253.     EntrySize = 20;
  254.  
  255.     n = (nEntries+1) * sizeof (*MenuILS);
  256.     if (!(MenuILS = (MENU *) memory_alloc (n)))
  257.         return (1);
  258.  
  259.     sel = MENU_FAILED;
  260.     for (i = 0; i < nEntries; ++i)
  261.         if (!(MenuILS[i].text = (char *) memory_alloc (EntrySize)))
  262.             goto ret;
  263.  
  264.     MenuILS[0].letter = '0';
  265.     strcpy (MenuILS[0].text, "Off");
  266.     for (i = 1; i < nEntries-1; ++i) {
  267.         MenuILS[i].letter = i+'0';
  268.         strcpy (MenuILS[i].text, ils[i-1].name);
  269.     }
  270.     MenuILS[i].letter = '=';
  271.     strcpy (MenuILS[i].text, "Home");
  272.  
  273.     sel = p ? EX->ils : 0;
  274.     sel = menu_open (MenuILS, sel);
  275.  
  276.     if (p) {
  277.         switch (sel) {
  278.         case MENU_ABORTED:
  279.         case MENU_FAILED:
  280.             break;
  281.         case 0:
  282.             EX->hud2 &= ~HUD_ILS;
  283.             break;
  284.         default:
  285.             if (sel == nEntries-1)
  286.                 sel = st.home+1;
  287.             if (EX->ils == sel) {
  288.                 EX->hud2 ^= HUD_ILS;
  289.                 break;
  290.             }
  291.             EX->hud2 |= HUD_ILS;
  292.             EX->ils = sel;
  293.             EX->misc[14] = 0;
  294.             break;
  295.         }
  296.     } else
  297.         MsgWPrintf (100, "not a aplane");
  298. ret:
  299.     for (i = 0; i < nEntries; ++i)
  300.         if (MenuILS[i].text)
  301.             memory_free (MenuILS[i].text, EntrySize);
  302.  
  303.     memory_free (MenuILS, n);
  304.  
  305.     if (MENU_FAILED == sel)
  306.         return (1);
  307.  
  308.     menu_close ();
  309.     return (0);
  310. }
  311.  
  312. extern int FAR
  313. nav_find (char *name)
  314. {
  315.     int    i;
  316.  
  317.     if (!name)
  318.         return (0);
  319.     for (i = 0; ils[i].name; ++i) {
  320.         if (!stricmp (ils[i].name, name))
  321.             return (i);
  322.     }
  323.     if (!name[0])
  324.         return (i-1);
  325.     return (-1);
  326. }
  327.